http://bit.ly/jmb-cpoa http://iut-blagnac.github.io/cpoa/
-
Ce cours porte sur la Conception et Programmation Objet Avancée.
Vous avez appris (cf. M2103 et M2104) un certain nombre de concepts objets :
Définition :
Définition (restrictive) :
Une classe est une abstraction des caractéristiques communes d’un ensemble d’objets.
Définition :
Définition (restrictive) :
Dans la description d’un objet, le but de l'encapsulation est de masquer les attributs et les méthodes, c’est-à-dire, la manière dont est réalisé le comportement de l’objet.
Définition :
Définition (simpliste) :
L’héritage est la transmission de caractéristiques à ses descendants.
La classe qui hérite dispose des méthodes et attributs de niveau public et
protected de sa classe mère.
Le nom de polymorphisme vient du grec :
Le nom de polymorphisme vient du grec :
qui peut prendre plusieurs formes
L’héritage concerne les classes, le polymorphisme concerne les objets. |
On distingue généralement trois types de polymorphisme :
int method(int,int);
int method(int);
int method(float,float);Appelé aussi généricité.
interface Iterator<E> {
boolean hasNext();
E next();
}
public <T> static void copy(Collection<? extends T> source, Collection<? super T> dest) {
for (T t : source) {
dest.add(t);
}
}On essaye d’éviter trois problèmes principaux du développement :
Pour répondre aux problèmes ci-dessus, on va s’attaquer à diminuer les dépendances et éviter l'"effet spaghetti".
Les qualités recherchées sont :
Nous allons apprendre des bonnes pratiques :
L’étape suivante consiste à apprendre les bonnes solutions de conception, ce qu’on appelle les patrons de conception (ou design patterns en anglais).
Rappel du rythme : 1 cours, 1 TD et 2 TPs par semaine. Pendant 8 semaines. |
Le cours est inversé par rapport aux habitudes :
Conception et étude d’un ou plusieurs patrons semaine |
Voici une proposition de déroulement des semaines :
Observable)JTable de JavaComme prévu par le planning des contrôles, les étudiants auront :
Le fait d’attribuer un type (une classe) à une variable (un objet) peut se faire de plusieurs façons :
On parle de typage statique quand la majorité des vérifications de type sont effectuées au moment de la compilation.
int i = 0; // cette déclaration indique explicitement que
// la variable i est de type entierLe typage dynamique consiste à laisser l’ordinateur réaliser l’opération de typage à la volée, lors de l’exécution du code.
/**
* @author André Peninou
*/
public class Type {
void m() {
System.out.println ("Type");
}
}
public class SousType extends Type {
void m() {
System.out.println ("SousType");
}
void autreM(){
System.out.println ("Spécifique SousType");
}
}
...
Type a = new Type();
a.m(); // "Type"
a = new SousType();
a.m(); // "SousType"
// Statique : a est un Type (à la compil)
// Dynamique : a est un SousType au runtime.
// D'où :
a = new SousType();
a.autreM();
// NOK car type statique == A => autreM() n'existe pas à la compilation
...Style de typage dynamique où la sémantique d’un objet (c’est-à-dire son type) est déterminée par l’ensemble de ses méthodes et de ses attributs, et non par un type défini et nommé explicitement par le programmeur.
L’origine de cette expression est liée à cette citation :
|
def calcule(a, b, c)
return a*b+c
end
$a = calcule(6, 3, 2)
$b = calcule('6', 3, ', the number of the beast')
puts $a.to_s
puts $b.to_sCe qui donne :
20 666, the number of the beast
| Pour aller plus loin : http://fr.wikipedia.org/wiki/Duck_typing |
Dès que l’on commence à avoir une application conséquente, l’organisation en package devient obligatoire. Revenons donc sur les questions de visibilité des propriétés et méthodes, qui seront importants dans la plupart des aspects de ce module.
Si un champ d’une classe A :
A mais de nulle part ailleurs ;A et,
si A est publique, grosso modo dans les classes héritant de A dans d’autres
paquetages ;A et,
si A est publique, de partout ailleurs.| Ci-dessus, les niveaux de visibilité sont rangés par visibilité croissante. |
package UN;
public class A {
protected String attrprotected;
String attrfriend; // friend
}Si on définit une deuxième classe dans le même package :
package UN;
class B {
...
{
A a = new A ();
a.attrprotected// OK : même si bizarre
a.attrfriend // OK : visible package
}
}
package UN;
class C extends A {
...
{
this.attrprotected// OK : normal
this.attrfriend // OK : visible package
}
}package DEUX;
class B {
...
{
A a = new A ();
a.attrprotected// NON OK : normal
a.attrfriend // NON OK : normal, proche de "private"
}
}
class C extends A {
...
{
this.attrprotected// OK : normal car protected et héritage
this.attrfriend // NON OK : normal, proche de "private"
}
}À la question private ou protected ? Quel est le mieux pour les attributs ?
| Il n’y a pas de visibilité par défaut en UML™. |
staticclass VariableDemo
{
static int count=0;
public void increment()
{
count++;
}
public static void main(String args[])
{
VariableDemo obj1=new VariableDemo();
VariableDemo obj2=new VariableDemo();
obj1.increment();
obj2.increment();
System.out.println("Obj1: count is="+obj1.count);
System.out.println("Obj2: count is="+obj2.count);
}
}Output:
Obj1: count is=2 Obj2: count is=2
static (suite)Comment ça marche :
static sont initialisées au chargement de la classe.static d’une classe sont
initialisées avant que la moindre instance ne soit créée.static sont initialisées avant que la moindre méthode static ne s’exécute.staticimport java.lang.Math;
class Another {
public static void main(String[] args) {
int result;
result = Math.min(10, 20); //calling static method min by writing class name
System.out.println(result);
System.out.println(Math.max(100, 200));
}
}static et appel aux méthodes non-statiquespublic class Main {
public static void main(String[] args) {
Main p = new Main();
k();
}
protected Main() {
System.out.print("1234");
}
protected void k() {
}
}À l’exécution :
Main p = new Main(); // => prints 1234
k() // => raises errorstatic et appel aux méthodes non-statiques (suite)Static method cannot call non-static methods
Bien sûr que si, sauf qu’il faut que cette dernière porte sur une instance de la classe.
static et appel aux méthodes non-statiques (suite)Constructors are kind of a method with no return type.
En fait il vaudrait mieux les considérer comme une sorte de méthode statique. En effet elle ne requièrent pas de porter sur un objet!
enumLe type enumération est souvent utilisé en modélisation :
public enum Civilite {
MADAME, MONSIEUR
}enum héritent de java.lang.EnumtoString()System.out.println(Civilite.MADAME); //MADAMEvalueOf()Civilite civilite = Civilite.valueOf("MONSIEUR") ;values()Civilite[] civilites = Civilite.values() ;ordinal()Civilite civilite = Civilite.MONSIEUR ;
System.out.println("Civilite : " + civilite + " [" + civilite.ordinal() + "]") ;
// Civilite : MONSIEUR [1]| Le 1er numéro d’ordre est 0. |
compareTo()System.out.println(Civilite.MADAME.compareTo(Civilite.MONSIEUR)) ;
// -1public enum Langage {
//Objets directement construits
JAVA("Langage JAVA", "Eclipse"),
C ("Lanage C", "Code Block"),
CPlus ("Langage C++", "Visual studio"),
PHP ("Langage PHP", "PS Pad");
private String name = "";
private String editor = "";
//Constructeur
Langage(String name, String editor){
this.name = name;
this.editor = editor;
}
public void getEditor(){
System.out.println("Editeur : " + editor);
}
public String toString(){
return name;
}
public static void main(String args[]){
Langage l1 = Langage.JAVA;
Langage l2 = Langage.PHP;
l1.getEditor();
l2.getEditor();
}
}QUESTION
|